//package com.example.lib_base.socket;
//
//import android.app.Service;
//import android.content.Intent;
//import android.os.Binder;
//import android.os.IBinder;
//import android.os.SystemClock;
//import android.text.TextUtils;
//import android.util.Log;
//
//import java.io.ByteArrayOutputStream;
//import java.io.IOException;
//import java.io.InputStream;
//import java.io.OutputStream;
//import java.io.PrintStream;
//import java.net.InetSocketAddress;
//import java.net.Socket;
//import java.net.SocketAddress;
//import java.nio.charset.StandardCharsets;
//import java.util.HashMap;
//import java.util.List;
//import java.util.Map;
//import java.util.concurrent.ArrayBlockingQueue;
//import java.util.concurrent.CopyOnWriteArrayList;
//import java.util.concurrent.Executors;
//import java.util.concurrent.Future;
//import java.util.concurrent.ScheduledExecutorService;
//import java.util.concurrent.ThreadFactory;
//import java.util.concurrent.ThreadPoolExecutor;
//import java.util.concurrent.TimeUnit;
//
//import protobuf.PacketProto;
//
//public class SocketClientService extends Service {
//    private static final String TAG = "SocketClientService";
//
//    private String ipAddress = "";                //服务器ip地址
//    private int serverPort = 3000;                //服务器端口号
//    private Socket socket = null;
//    private InputStream mInputStream;
//    private OutputStream mOutputStream;
//
//    private final List<Command> commandList = new CopyOnWriteArrayList<>();
//    private String lastIndex = "";
//    private Boolean sendStatus = false;
//
//    private Boolean socketStatus = false;
//    private Boolean copConnectPcStatus = false;
//    private Boolean pcConnectCopStatus = false;
//    private Boolean clientCloseStatus = false;      //是否关闭客户端
//
//    private Boolean pingTimeOut = false;            //是否ping超时
//    private Boolean waitReplyTimeOut = false;       //是否等待回复超时
//    private Boolean pcConnectCopError = false;      //是否pcConnectCop出错
//    private Boolean sendThreadError = false;        //是否发送线程出错
//    private Boolean receiveThreadError = false;     //是否接收出错
//
//    private Integer reconnectCounts = 0;            //重连次数
//
//    private Integer lastSendCommandNum = 0;         //最后发送的命令编号，用于与重发定时器匹配对应的命令计时
//    private Command lastReceviceMessage = new Command("", "");        //最后一条收到的消息，用于判断命令是否重复发送，重复的命令则忽略不处理
//    private Command lastSendMessage = new Command("", "");            //最后一条发送的消息，用于判断命令是否需要重发
//
//    private Integer pingErrCounts = 0;              //ping出错的次数
//
//    private int timeOutCounts = 0;                  //计时器超时次数
//    private Integer initTimerCommandNum;            //初始化计时器命令编号
//    private String initTimerCommand = null;         //初始化计时器命令
//
//    public List<Command> dealMessageList = new CopyOnWriteArrayList<>();     //待处理消息队列
//
//    //保存定时器任务的future，用以达到目的时销毁任务
//    private final Map<String, Future<?>> futures = new HashMap<String, Future<?>>();
//
//    private final ThreadFactory threadFactory = new ThreadFactoryUtil("communicate-thread-");
//
//    private final ThreadPoolExecutor executor = new ThreadPoolExecutor(20, 20, 200, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(5), threadFactory);
//
//    //将此类隐藏起来，做成实现接口的形式不暴露里面具体执行的内容
//    private class InnerBinder extends Binder implements ISocketClient {
//
//        @Override
//        public void initSocketClient(String ipAddr, int port) {
//            init(ipAddr, port);
//        }
//
//        @Override
//        public void sendCommand(Command command) {
//            if (socketStatus && pcConnectCopStatus && copConnectPcStatus) {
//                //据了解，C++/C#那边，每次发送完命令会间隔50ms再发下一条命令 huangtao-20220209
//                SystemClock.sleep(50);
//                commandList.add(command);
//            }
//        }
//
//        @Override
//        public void resetUserInitStatus() {
//            synchronized (commandList) {
//                commandList.clear();
//            }
//            if (socketStatus && pcConnectCopStatus && copConnectPcStatus) {
//                if (futures.get("replyTimer") != null) {
//                    futures.get("replyTimer").cancel(true);
//                    futures.remove("replyTimer");
//                }
//
//                synchronized (sendStatus) {
//                    sendStatus = true;
//                }
//                lastIndex = "";
//
//                pingTimeOut = false;
//                pcConnectCopError = false;
//                waitReplyTimeOut = false;
//                sendThreadError = false;
//                receiveThreadError = false;
//
//                //重置相关全局变量
//                //ServiceCommonUtil.resetGlobalFlag();
//            }
//        }
//
//        @Override
//        public boolean getConnectStatus() {
//            return socketStatus && pcConnectCopStatus && copConnectPcStatus;
//        }
//    }
//
//    @Override
//    public IBinder onBind(Intent intent) {
//        return new InnerBinder();
//    }
//
//    @Override
//    public void onCreate() {
//        super.onCreate();
//        socketStatus = false;
//        Log.d(TAG, "onCreate....");
//    }
//
//    @Override
//    public int onStartCommand(Intent intent, int flags, int startId) {
//        Log.d(TAG, "onStartCommand....");
//        return super.onStartCommand(intent, flags, startId);
//    }
//
//    @Override
//    public void onDestroy() {
//        super.onDestroy();
//        Log.d(TAG, "onDestroy....");
//    }
//
//    @Override
//    public boolean onUnbind(Intent intent) {
//        Log.d(TAG, "onUnbind....");
//
//        clientCloseStatus = true;
//        connectError();
//
//        //退出需要清空待处理消息缓冲区
//        commandList.clear();
//        dealMessageList.clear();
//
//        //关闭线程池
//        executor.shutdownNow();
//
//        return super.onUnbind(intent);
//    }
//
//    /**
//     * 连接出错处理，清理各变量的值
//     */
//    private void connectError() {
//        final Future<?> future1 = futures.get(CommuConstants.TASK_PC_CONNECT_COP);
//        if (future1 != null) {
//            future1.cancel(true);
//            futures.remove(CommuConstants.TASK_PC_CONNECT_COP);
//        }
//        final Future<?> future2 = futures.get("replyTimer");
//        if (future2 != null) {
//            future2.cancel(true);
//            futures.remove("replyTimer");
//        }
//        final Future<?> future3 = futures.get(CommuConstants.TASK_PINGSERVER);
//        if (future3 != null) {
//            future3.cancel(true);
//            futures.remove(CommuConstants.TASK_PINGSERVER);
//        }
//        final Future<?> future4 = futures.get(CommuConstants.TASK_UPDATE_BIO_OVERVIEW_LIST);
//        if (future4 != null) {
//            future4.cancel(true);
//            futures.remove(CommuConstants.TASK_UPDATE_BIO_OVERVIEW_LIST);
//        }
//
//        if (socket != null) {
//            try {
//                socket.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }
//        socket = null;
//        socketStatus = false;
//        mInputStream = null;
//        mOutputStream = null;
//        pcConnectCopStatus = false;
//        copConnectPcStatus = false;
//
//        //获取所有线程
//        ThreadGroup currentGroup = Thread.currentThread().getThreadGroup();
//        if (currentGroup != null) {
//            int noThreads = currentGroup.activeCount();
//            Thread[] lstThreads = new Thread[noThreads];
//            currentGroup.enumerate(lstThreads);
//            for (int i = 0; i < noThreads; i++) {
//                if (lstThreads[i] != null) {
////                lstThreads[i].getName();
//                    if (lstThreads[i].getName().contains("communicate-thread-")) {
//                        lstThreads[i].interrupt();
//                    }
//                }
//            }
//        }
//        lastIndex = "";
//        synchronized (sendStatus) {
//            sendStatus = false;
//        }
//
//        reconnectCounts = 0;
//        pingErrCounts = 0;
//        timeOutCounts = 0;
//        lastReceviceMessage = new Command("", "");
//        lastSendCommandNum = 0;
//
//        CommuCache.indexId = 1;
//
//        //重置全局变量参数
//        //ServiceCommonUtil.resetGlobalFlag();
//        //使用eventbus通知改变界面状态
//        //EventBus.getDefault().post(new EventBusTool.UpdateMacroBtnStatusEvent());
//        //通信出错消息通知
////        EventBus.getDefault().post(new CommonEvent.SocketConnectErrEvent());
//    }
//
//    /**
//     * 客户端初始化
//     */
//    private void init(String ipAddr, int port) {
//        socketStatus = false;
//        clientCloseStatus = false;
////        LogUtils.clearLogCache();
//        //启动日志写入线程
//        //WriteLogThread writeLogThread = new WriteLogThread();
//        //executor.execute(writeLogThread);
//        //启动client初始化线程
//        clientInit(ipAddr, port);
//    }
//
//    /**
//     * socket连接线程（重连线程也是这个）
//     */
//    private void clientInit(final String ipAddr, final int port) {
//        ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
//        Future<?> future = executorService.scheduleAtFixedRate(new Runnable() {
//            @Override
//            public void run() {
//                if (clientCloseStatus || socketStatus) {
//                    Future<?> future = futures.get("clientInit");
//                    if (future != null) {
//                        future.cancel(true);
//                        futures.remove("clientInit");
//                    }
//                    return;
//                }
//                if (!socketStatus) {
//                    try {
//                        //连接socket
//                        socket = new Socket();
//                        SocketAddress socAddress = new InetSocketAddress(ipAddr, port);
//                        //客户端socket close之后，原来的端口进入TIME_WAIT，要好几分钟才释放，所以得复用原来的端口，
//                        // 否则关闭socket后短时间内打开会有端口占用的问题
//                        socket.setReuseAddress(true);
////                        String smallScreenPort = ConstantsCache.userConnectSettingMap.get(XmlTagAttrConstants.SMALL_SCREEN_PORT);
////                        if (TextUtils.isEmpty(smallScreenPort)) {
////                            smallScreenPort = "58673";
////                        }
//                        socket.bind(new InetSocketAddress(Integer.parseInt(smallScreenPort)));
//                        socket.connect(socAddress, 1000);
//
//                        System.out.println("socket连接成功");
////                        LogUtils.writeLogWithStr("socket连接成功");
//                        socketStatus = true;
//                        //保存好ip和端口号
//                        ipAddress = ipAddr;
//                        serverPort = port;
//                        mInputStream = socket.getInputStream();
//                        mOutputStream = socket.getOutputStream();
//
//                        //启动接收线程
//                        ReceiveThread receiveThread = new ReceiveThread();
//                        executor.execute(receiveThread);
//
//                        MessageDealThread messageDealThread = new MessageDealThread();
//                        executor.execute(messageDealThread);
//
//                        //启动pc连接cop线程
//                        if (!pcConnectCopStatus) {
//                            pcConnectCop();
//                        }
//
//                        //启动发送线程
//                        SendThread sendThread = new SendThread();
//                        executor.execute(sendThread);
//
////                        //启动计时器线程
////                        reSendTimer();
//
//                        //关闭定时器
//                        Future<?> future = futures.get("clientInit");
//                        if (future != null) {
//                            future.cancel(true);
//                            futures.remove("clientInit");
//                        }
//                    } catch (IOException e) {
//                        //如果存在未发送的命令
//                        if (commandList.size() > 0) {
//                            reconnectCounts++;
//                        }
//                        if (reconnectCounts == 5 && commandList.size() > 0) {
//                            System.out.println("socket重连失败，重置命令缓冲区，继续进行重连");
////                            LogUtils.writeLogWithStr("socket连接失败，尝试重连");
//                            CommuCache.indexId = 1;
//                            commandList.clear();
//                            dealMessageList.clear();
//                            reconnectCounts = 0;
//                        } else {
//                            System.out.println("socket连接失败，尝试重连");
////                            LogUtils.writeLogWithStr("socket连接失败，尝试重连");
//                        }
//                    }
//                }
//            }
//        }, 0, 1000, TimeUnit.MILLISECONDS);
//        futures.put("clientInit", future);
//    }
//
//    /**
//     * @return
//     * @Author: litianzhu
//     * @Date: 15:07 2019-05-20
//     * @Description: pc连接cop线程
//     * @Param: null
//     */
//    private void pcConnectCop() {
//        ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
//        Future<?> future = executorService.scheduleAtFixedRate(new Runnable() {
//            @Override
//            public void run() {
//                if (pcConnectCopStatus) {
//                    Future<?> future = futures.get(CommuConstants.TASK_PC_CONNECT_COP);
//                    if (future != null) {
//                        future.cancel(true);
//                        futures.remove(CommuConstants.TASK_PC_CONNECT_COP);
//                    }
//                    //更新界面指示灯状态
//                    //EventBus.getDefault().post(new CommunicateStatusEvent(true, true));
//                } else {
//                    try {
//                        Command connectCommand = ConstantsCache.connectCommandMap.get(CopConstant.IPAD_CONNECT);
//                        connectCommand.setCheckSum(CommandTool.getCheckSum(connectCommand));
//                        //拿到请求连接的命令
//                        String message = CommandTool.commandToString(connectCommand);
//                        handleUserConnect();
//                        //请求系统信息
//                        Command rqSysInfoCmd = CommandTool.getReqSysInfoCmd();
//                        sendCommand(rqSysInfoCmd);
//                        // TODO: 2021/12/24 100是临时写死，后续要放配置文件
//                        CommandTool.sendData(rqCmd, mOutputStream);
//                        //然后将消息再次发送出去
//                        mOutputStream.write(message.getBytes(StandardCharsets.UTF_8));
//                        //mOutputStream.flush();
//                        System.out.println("client:-->" + message);
//                    } catch (Exception e) {
//                        synchronized (pcConnectCopError) {
//                            pcConnectCopError = true;
//                        }
//                        //更新界面指示灯状态
//                        //EventBus.getDefault().post(new CommunicateStatusEvent(false, false));
//                        if (!waitReplyTimeOut && !receiveThreadError && !sendThreadError && !pingTimeOut) {
//                            connectError();
//                            //重新打开网口进行连接
//                            if (futures.get("clientInit") == null) {
//                                clientInit(ipAddress, serverPort);
//                            }
//                        }
//                        e.printStackTrace();
//                    }
//                }
//
//            }
//        }, 0, 1000, TimeUnit.MILLISECONDS);
//        futures.put(CommuConstants.TASK_PC_CONNECT_COP, future);
//    }
//
//    /**
//     * 功能描述: 发送命令
//     */
//    private void sendCommand(Command command) {
//        if (socketStatus && pcConnectCopStatus && copConnectPcStatus) {
//            //据了解，C++/C#那边，每次发送完命令会间隔50ms再发下一条命令 huangtao-20220209
//            SystemClock.sleep(50);
//            commandList.add(command);
//        }
//    }
//
//    /**
//     * ping服务器ip，检查网络是否连通
//     */
//    private void pingServer() {
//        ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
//        Future<?> future = executorService.scheduleAtFixedRate(new Runnable() {
//            @Override
//            public void run() {
//                //客户端关闭则关闭此定时器，软件与下位机连接成功之后才执行心跳包检测
//                if (!clientCloseStatus && socket != null && pcConnectCopStatus && copConnectPcStatus) {
//                    //软件与下位机连接成功之后才执行ping
//                    try {
//                        Process p = Runtime.getRuntime().exec("/system/bin/ping -c 1 -w " + CommuConstants.PING_TIME_OUT + " " + ipAddress);
//                        int status = p.waitFor();
//                        //System.out.println("p.waitFor() :" + pv);
//                        //int status = p.exitValue();
//                        //System.out.println("p.exitValue() :" + status);
//                        if (status == 0) {
//                            pingErrCounts = 0;
//                            System.out.println("ping success");
//                        } else {
//                            System.out.println("ping fail");
//                            pingErrCounts++;
//                            if (pingErrCounts.equals(CommuConstants.PING_ERR_COUNTS)) {
//                                //关闭定时器
//                                Future future = futures.get(CommuConstants.TASK_PINGSERVER);
//                                if (future != null) {
//                                    future.cancel(true);
//                                    futures.remove(CommuConstants.TASK_PINGSERVER);
//                                }
//                                //更新界面指示灯状态
//                                //EventBus.getDefault().post(new CommunicateStatusEvent(false, false));
//                                System.out.println("ping检测超时");
//                                synchronized (pingTimeOut) {
//                                    pingTimeOut = true;
//                                }
//                                if (!waitReplyTimeOut && !receiveThreadError && !sendThreadError && !pcConnectCopError) {
//                                    connectError();
//                                    //重新打开网口进行连接
//                                    if (futures.get("clientInit") == null) {
//                                        clientInit(ipAddress, serverPort);
//                                    }
//                                }
//                            }
//                        }
//                        p.getInputStream().close();
//                        p.getOutputStream().close();
//                        p.getErrorStream().close();
//                    } catch (IOException | InterruptedException e) {
//                        if (!pingTimeOut) {
//                            synchronized (pingTimeOut) {
//                                pingTimeOut = true;
//                            }
//                            if (!waitReplyTimeOut && !receiveThreadError && !sendThreadError && !pcConnectCopError) {
//                                synchronized (LogConstantsCache.LOG_CONTENT_CACHE_LIST) {
//                                    String logContent = "连接出错，client退出发送ping线程";
//                                    LogConstantsCache.LOG_CONTENT_CACHE_LIST.add(logContent);
//
//                                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
//                                    e.printStackTrace(new PrintStream(baos));
//                                    /*String exceptionMessage = baos.toString();
//                                    LogConstantsCache.LOG_CONTENT_CACHE_LIST.add("网口ping具体异常信息:" + exceptionMessage);*/
//                                }
//                                /*//清除各变量的值
//                                connectError();
//                                //重新打开网口进行连接
//                                if (futures.get("clientInit") == null) {
//                                    synchronized (LogConstantsCache.LOG_CONTENT_CACHE_LIST) {
//                                        String logContent1 = "连接出错，启动重连线程";
//                                        LogConstantsCache.LOG_CONTENT_CACHE_LIST.add(logContent1);
//                                    }
//                                    clientInit(ipAddress, serverPort);
//                                }*/
//                            }
//                            e.printStackTrace();
//                        }
//                    }
//                } else {
//                    //关闭定时器
//                    Future<?> future = futures.get(CommuConstants.TASK_PINGSERVER);
//                    if (future != null) {
//                        future.cancel(true);
//                        futures.remove(CommuConstants.TASK_PINGSERVER);
//                    }
//                }
//            }
//        }, 0, CommuConstants.PING_INTERVAL, TimeUnit.MILLISECONDS);
//        futures.put(CommuConstants.TASK_PINGSERVER, future);
//    }
//
//    /**
//     * 消息接收线程
//     */
//    private class ReceiveThread implements Runnable {
//        @Override
//        public void run() {
//            //final byte[] bytes = new byte[1024];
//            StringBuilder message = new StringBuilder();
//            String cmdType = "";
//            while (socketStatus && socket != null) {
//                try {
//                    try {
//                        Thread.sleep(2);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                        break;
//                    }
//                    if (mInputStream == null || !socketStatus) {
//                        break;
//                    }
//                    //然后读取指定长度的消息即可
//                    //int size = mInputStream.read(bytes);
//                    PacketProto.Packet rcvPacket = PacketProto.Packet.parseDelimitedFrom(mInputStream);
//                    cmdType = rcvPacket.getCmdtype();
//                    Log.d(TAG, "命令枚举类型：" + rcvPacket.getCmdtype());
//                    String result = rcvPacket.getData();
//                    if (TextUtils.isEmpty(result)) {
//                        synchronized (receiveThreadError) {
//                            receiveThreadError = true;
//                        }
//                        //更新界面指示灯状态
//                        //EventBus.getDefault().post(new CommunicateStatusEvent(false, false));
//                        if (!pingTimeOut && !pcConnectCopError && !waitReplyTimeOut && !sendThreadError) {
//                            //清除各变量的值
//                            connectError();
//                            //启动重连线程
//                            if (futures.get("clientInit") == null) {
////                                LogUtils.writeLogWithStr("连接出错，启动重连线程");
//                                clientInit(ipAddress, serverPort);
//                            }
//                        }
//                    } else {
//                        System.out.println("消息长度为" + result.length());
////                        String result = ConversionTool.bytes2HexString(bytes, size);
////                        String result = new String(bytes, 0, size, StandardCharsets.UTF_8);
//                        Log.d(TAG, "接收到的数据：");
//                        //我们采取分段打印日志的方法：当长度超过4000时，我们就来分段截取打印
//                        //剩余的字符串长度如果大于4000
//                        if (result.length() > 4000) {
//                            for (int i = 0; i < result.length(); i += 4000) {
//                                //当前截取的长度<总长度则继续截取最大的长度来打印
//                                if (i + 4000 < result.length()) {
//                                    Log.i(TAG + i, result.substring(i, i + 4000));
//                                } else {
//                                    //当前截取的长度已经超过了总长度，则打印出剩下的全部信息
//                                    Log.i(TAG + i, result.substring(i, result.length()));
//                                }
//                            }
//                        } else {
//                            //直接打印
//                            Log.i(TAG, result);
//                        }
//                        if (!message.toString().startsWith(CommuConstants.CMD_START)) {
//                            //如果上一次保留的数据开头不是指定格式的，那么该数据需要丢弃 huangtao-20211130
//                            message.delete(0, message.length());
//                        }
//
//                        message.append(result);
//                        // 判断message是否是完整的命令,是的话则新建数据处理线程进行处理
//                        if (message.toString().startsWith(CommuConstants.CMD_START) && message.toString().endsWith(CommuConstants.CMD_END)) {
//                            String dealMessage = message.toString();
//                            //去掉多余的换行符
//                            dealMessage = dealMessage.replaceAll("\r|\n", "");
//                            //10:CommuConstants.CMD_END.length()代表</xmlRoot>的长度
//                            if (dealMessage.lastIndexOf(CommuConstants.CMD_START) == 0
//                                    && dealMessage.indexOf(CommuConstants.CMD_END) == (dealMessage.length() - CommuConstants.CMD_END.length())) {
//                                //一般情况下，正常单条命令
//                                Command dealCmd = new Command(cmdType, dealMessage);
//                                dealMessageList.add(dealCmd);
//                                lastReceviceMessage = dealCmd;
//
//                                //我们采取分段打印日志的方法：当长度超过4000时，我们就来分段截取打印
//                                //剩余的字符串长度如果大于4000
//                                if (dealMessage.length() > 4000) {
//                                    Log.i(TAG, "get message from server: <--");
//                                    for (int i = 0; i < dealMessage.length(); i += 4000) {
//                                        //当前截取的长度<总长度则继续截取最大的长度来打印
//                                        if (i + 4000 < dealMessage.length()) {
//                                            Log.i(TAG + i, dealMessage.substring(i, i + 4000));
//                                        } else {
//                                            //当前截取的长度已经超过了总长度，则打印出剩下的全部信息
//                                            Log.i(TAG + i, dealMessage.substring(i));
//                                        }
//                                    }
//                                } else {
//                                    //直接打印
//                                    Log.i(TAG, "get message from server: <--" + dealMessage);
//                                }
//                            } else {
//                                StringBuilder dealBuilder = new StringBuilder(dealMessage);
//                                while (dealBuilder.length() > 0) {
//                                    String subMessage = dealBuilder.substring(0, dealMessage.indexOf(CommuConstants.CMD_END) + 10);
//                                    if (subMessage.startsWith(CommuConstants.CMD_START) && subMessage.endsWith(CommuConstants.CMD_END)) {
//                                        Command subCmd = new Command(cmdType, subMessage);
//                                        dealMessageList.add(subCmd);
//                                        lastReceviceMessage = subCmd;
//                                        System.out.println("get message from server: <--" + subMessage);
//                                        //先添加进入日志
//                                    }
//                                    //清除已处理的数据
//                                    dealBuilder.delete(0, subMessage.length());
//                                }
//                            }
//
//                            //清除已处理的数据
//                            message.delete(0, message.length());
//                        }
//                    }
//                } catch (Exception e) {
//                    synchronized (receiveThreadError) {
//                        receiveThreadError = true;
//                    }
//                    //更新界面指示灯状态
//                    //EventBus.getDefault().post(new CommunicateStatusEvent(false, false));
//                    if (!pingTimeOut && !pcConnectCopError && !waitReplyTimeOut && !sendThreadError) {
//                        //清除各变量的值
//                        connectError();
//                        //启动重连线程
//                        if (futures.get("clientInit") == null) {
//                            clientInit(ipAddress, serverPort);
//                        }
//                    }
//                    e.printStackTrace();
//                    break;
//                }
//            }
//        }
//    }
//
//    /**
//     * 数据处理线程
//     */
//    private class MessageDealThread implements Runnable {
//
//        @Override
//        public void run() {
//            while (socketStatus && socket != null) {
//                try {
//                    Thread.sleep(2);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                    break;
//                }
//                if (dealMessageList.size() > 0) {
//                    Command command = CommandTool.stringToCommand(String.valueOf(dealMessageList.get(0).getCmdType()),
//                            dealMessageList.get(0).getContent());
//                    if (!TextUtils.isEmpty(command.getContent())) {
//                        switch (command.getCmdType()) {
//                            default:
//                                break;
//                        }
//                    }
//                    /*由于在频繁快速反复进行“进入、退出service”的操作时，偶然出现IndexOutOfBoundsException的边界异常，所以在删除之前再进行一次判断*/
//                    if (dealMessageList != null && dealMessageList.size() > 0) {
//                        dealMessageList.remove(0);
//                    }
//                }
//            }
//        }
//    }
//
//
//    /**
//     * 发送线程
//     */
//    private class SendThread implements Runnable {
//        @Override
//        public void run() {
//            while (socketStatus && socket != null) {
//                try {
//                    Thread.sleep(3);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                    break;
//                }
//                if (commandList.size() > 0 && "".equals(lastIndex)) {
//                    synchronized (sendStatus) {
//                        sendStatus = true;
//                    }
//                }
//                //判断是否有消息需要发送
//                if (pcConnectCopStatus && copConnectPcStatus && sendStatus && commandList.size() > 0) {
//                    Command command = commandList.get(0);
////                        command.setIndex(CommandTool.getIndex());
////                        command.setCheckSum(CommandTool.getCheckSum(command));
//                    //从消息列表拿到消息
////                        String message = CommandTool.commandToString(command);
//                    String message = command.getContent();
//                    synchronized (sendStatus) {
//                        //然后将消息的转化为字节数组
//                        //byte[] sendBytes = message.getBytes(StandardCharsets.UTF_8);
////                            CommandTool.sendData(command, mOutputStream);
//                        //然后将消息再次发送出去
//                        //mOutputStream.write(sendBytes);
//                        //mOutputStream.flush();
//
//                        sendStatus = false;
//
//                        //保存最后一次发送命令的索引，判断该命令有没有回复Ack
//                        synchronized (lastIndex) {
//                            synchronized (commandList) {
//                                if (commandList.size() > 0) {
//                                    //lastIndex = commandList.get(0).getIndex();
//                                }
//                            }
//                        }
//                        synchronized (lastSendMessage) {
//                            lastSendMessage = command;
//                            if (lastSendCommandNum == 1000) {
//                                lastSendCommandNum = 1;
//                            } else {
//                                lastSendCommandNum++;
//                            }
//                        }
//                     }
//                    //如果是ack或者不符合规范的命令，则不用等待回复ack
//                    synchronized (sendStatus) {
//                        sendStatus = true;
//                    }
//                    synchronized (commandList) {
//                        commandList.remove(0);
//                    }
//                    if (futures.get("replyTimer") == null) {
//                        //启动计时器线程
//                        // TODO: 2021/11/29 暂时屏蔽重发定时器
//                        //reSendTimer(message);
//                    }
//                    System.out.println("client:-->" + message);
//                }
//            }
//
//        }
//    }
//
//    /**
//     * 重发消息定时器
//     */
//    private void reSendTimer(String command) {
//        initTimerCommand = command;
//        initTimerCommandNum = 1;
//        ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
//        final Future<?> future = executorService.scheduleAtFixedRate(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("消息重发计时器正在运行......" + Thread.currentThread().getName());
//                if (pcConnectCopStatus && copConnectPcStatus) {
//                    if (initTimerCommand != null && !"".equals(initTimerCommand) && !sendStatus) {
//                        //判断最后一次发送命令的索引与当前正在计时的索引是否同一个
//                        synchronized (lastSendMessage) {
//                            if (!"".equals(lastSendMessage.getContent()) && initTimerCommand.equals(lastSendMessage.getContent())
//                                    && initTimerCommandNum.equals(lastSendCommandNum)) {
//                                if (timeOutCounts < 4) {
//                                    try {
//                                        //从消息列表拿到消息
//                                        //String message = CommandTool.commandToString(commandList.get(0));
//                                        //然后将消息再次发送出去
////                                        mOutputStream.write(ConversionTool.hexString2Bytes(lastSendMessage.getContent()));
//                                        mOutputStream.flush();
//                                        System.out.println("计时器重发消息：" + lastSendMessage);
//                                        //String logContent = "-->" + StringTool.getStringAddSpace(lastSendMessage);
//                                        timeOutCounts++;
//                                    } catch (IOException e) {
//                                        synchronized (waitReplyTimeOut) {
//                                            waitReplyTimeOut = true;
//                                        }
//                                        //更新界面指示灯状态
//                                        //EventBus.getDefault().post(new CommunicateStatusEvent(false, false));
//
////                                        LogUtils.writeLogWithStr("连接出错，client退出重发消息计时器线程");
//                                        if (!pingTimeOut && !receiveThreadError && !sendThreadError && !pcConnectCopError) {
//                                            //清除各变量的值
//                                            connectError();
//                                            //启动重连线程
//                                            if (futures.get("clientInit") == null) {
////                                                LogUtils.writeLogWithStr("连接出错，启动重连线程");
//                                                clientInit(ipAddress, serverPort);
//                                            }
//                                        }
//                                        e.printStackTrace();
//                                    }
//                                } else if (timeOutCounts == 4) {
//                                    timeOutCounts = 0;
//                                    synchronized (waitReplyTimeOut) {
//                                        waitReplyTimeOut = true;
//                                    }
//                                    if (!pingTimeOut && !receiveThreadError && !sendThreadError && !pcConnectCopError) {
//                                        //清除各变量的值
//                                        connectError();
//                                        //重新打开串口进行连接
//                                        if (futures.get("clientInit") == null) {
//                                            clientInit(ipAddress, serverPort);
//                                        }
//                                    }
//                                }
//                            } else {
//                                //System.out.println("消息已回复，重置计时索引");
//                                timeOutCounts = 0;
//                                //重新设置计时的命令
//                                initTimerCommand = lastSendMessage.getContent();
//                                initTimerCommandNum = lastSendCommandNum;
//                            }
//                        }
//                    } else {
//                        //System.out.println("消息已回复，重置计时索引");
//                        timeOutCounts = 0;
//                        //重新设置计时的命令
//                        initTimerCommand = lastSendMessage.getContent();
//                        initTimerCommandNum = lastSendCommandNum;
//                    }
//                } else {
//                    if (futures.get("replyTimer") != null) {
//                        futures.get("replyTimer").cancel(true);
//                        futures.remove("replyTimer");
//                    }
//                }
//            }
//        }, 1000, 1000, TimeUnit.MILLISECONDS);
//        futures.put("replyTimer", future);
//    }
//
//    /**
//     * 功能描述: 处理连接
//     */
//    private void handleUserConnect() {
//        //响应连接
//        reconnectCounts = 0;
//        pcConnectCopStatus = true;
//        //关闭定时器
//        Future<?> future = futures.get(CommuConstants.TASK_PC_CONNECT_COP);
//        if (future != null) {
//            future.cancel(true);
//            futures.remove(CommuConstants.TASK_PC_CONNECT_COP);
//        }
//        if (copConnectPcStatus && commandList.size() > 0) {
//            lastIndex = "";
//        }
//
//        //改为接收到A5就算连接上
//        copConnectPcStatus = true;
//        synchronized (sendStatus) {
//            sendStatus = true;
//        }
//        lastIndex = "";
//        CommuCache.indexId = 1;
//
//        pingTimeOut = false;
//        pcConnectCopError = false;
//        waitReplyTimeOut = false;
//        sendThreadError = false;
//        receiveThreadError = false;
//
//        /*if (futures.get("replyTimer") == null) {
//            //启动计时器线程
//            reSendTimer();
//        }*/
//
//        //重置相关全局变量
//        //ServiceCommonUtil.resetGlobalFlag();
//
//        //更新界面指示灯状态
//        //EventBus.getDefault().post(new CommunicateStatusEvent(true, true));
//        if (futures.get(CommuConstants.TASK_PINGSERVER) == null) {
//            pingServer();
//        }
//    }
//
//}
